/*****************************************************************************
*                     Organizacion de Datos - 75.06                          *
*                         Catedra Lic. Servetto                              *
*            Facultad de Ingenieria - Universidad de Buenos Aires            *
******************************************************************************/ 

#include "../Comun/Operacion.h"

#include "CapaFisica.h"
#include "ConexionCapaIndices.h"

#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

using namespace std;
using namespace Comun;

int main(int argc, char* argv[])
{
	

	// Con este while true, funciona como un "servicio" ya que procesa un archivo y se queda esperando el siguiente.
	//while(true)
	//{
		stringstream entrada;
		stringstream salida;

		// File.WaitForFile(Comun::NombreArchivoEntradaCapaFisica);
		
		stringstream * s = new stringstream();
		*s << "Transacciones/CapaFisica/Entrada/" << argv[1] << ".txt";
		

		ifstream archivoEntrada(s->str().c_str());
		entrada << archivoEntrada.rdbuf();
		archivoEntrada.close();

		CapaFisica::Aplicacion::Correr(&entrada, &salida);

		delete s;
		s = new stringstream();

		*s << "Transacciones/CapaFisica/Salida/" << argv[1] << ".txt";

		ofstream archivoSalida(s->str().c_str());
		archivoSalida << salida.rdbuf();
		archivoSalida.close();

		// TODO: File.Delete(Comun::NombreArchivoEntradaCapaFisica);
	//}

	return 0;

	/*
	
	stringstream entrada;
	stringstream salida;

	if (argc > 1)
	{
		ifstream archivoEntrada(argv[1]);
		entrada << archivoEntrada.rdbuf();
	}

	CapaFisica::Aplicacion::Correr(&entrada, &salida);

	if (argc > 2)
	{
		ofstream archivoSalida(argv[2]);
		archivoSalida << salida.rdbuf();
	}
	else
		cout << salida.rdbuf();

	return 0;
*/
}

namespace CapaFisica
{

	void Aplicacion::Correr(stringstream* entrada, stringstream* salida)
	{
		ConexionCapaIndices::EjecutarLlamada(entrada, salida);
	};

}
















/************************************/

/*

#include "ManejadorEspacioLibre.h"
#include "Serializador.h"
#include "AdministradorDeArchivos.h"
#include "ConexionCapaIndices.h"
#include "ArchivoEnDisco.h"
#include "..\Comun\Archivo.h"
#include "Serializador.h"
#include <iostream>
#include <fstream>
#include <string>


int main()
{

	MetadatosArchivo &metadatosArchivo = *(new MetadatosArchivo("asdaf"));

	metadatosArchivo.MetadatosGrupo = new MetadatosGrupo();
	metadatosArchivo.MetadatosGrupo->MetadatosAtributos.push_back( *(new MetadatosAtributo("jodido", Booleano)) );
	metadatosArchivo.MetadatosGrupo->MetadatosAtributos.push_back( *(new MetadatosAtributo("peso", Entero)) );
	metadatosArchivo.MetadatosGrupo->MetadatosRegistro = new MetadatosRegistro();
	metadatosArchivo.MetadatosGrupo->MetadatosRegistro->MetadatosAtributos.push_back( *(new MetadatosAtributo("lala", Entero)) );
	metadatosArchivo.MetadatosGrupo->MetadatosRegistro->MetadatosAtributos.push_back( *(new MetadatosAtributo("poe", Cadena)) );

	AdministradorDeArchivos::Instancia().CrearClaseParaRF(metadatosArchivo); 

	ManejadorEspacioLibre* el = new MapaDeBits("test2",8192);

	for (int i = 0; i<100 ; i++){
		el -> ObtenerBloqueLibre(i*9);			
	}

	el -> Liberar(5);
	el -> Liberar(6);
	el -> Liberar(7);
	el -> Liberar(8);
	el -> Liberar(9);

	long tt = el -> ObtenerTamanioArchivo();
	cout << tt;

	el -> GuardarArchivo();

	fstream file;

	short ss[5] = {0,1,2,3,4};

	file.open("C:\\test.txt",ios::in|ios::out);		
	file << ss[0] << ss[1] << ss[2] << endl;
	file.close();

	int i = 34;
	char buffer[8];
	
	
	Atributo* a = new Atributo();
	a->Valor = new string("1");
	a->Tipo = 'B';
	Atributo* a1 = new Atributo();
	a1->Valor = new string("200.152");
	a1->Tipo = 'R';
	Atributo* a2 = new Atributo();
	a2->Valor = new string("abcdefghijklmnopqrstuvwxyz");
	a2->Tipo = 'S';
	Atributo* a3 = new Atributo();
	a3->Valor = new string("20071014");
	a3->Tipo = 'F';

	Metadata* met = new Metadata("Clase");
	Contenedor d(met);

	SerializadorContenedores sc(&d);
	char* buf = new char[1024];
	int final = sc.SerializarTipo(*a,buf,0);
	final = sc.SerializarTipo(*a1,buf,final);
	final = sc.SerializarTipo(*a2,buf,final);
	final = sc.SerializarTipo(*a3,buf,final);

	fstream file;
	file.open("datos.dat", ios::out );
	file.write(buf,1024);
	file.close();

	char* buf2 = new char[1024];

	fstream file2;
	file2.open("datos.dat", ios::in );
	file2.read(buf2,1024);
	
	Atributo* a4 = new Atributo();
	a4->Tipo = 'B';
	Atributo* a5 = new Atributo();
	a5->Tipo = 'R';
	Atributo* a6 = new Atributo();
	a6->Tipo = 'S';
	Atributo* a7 = new Atributo();
	a7->Tipo = 'F';

	final = sc.DeSerializarTipo(*a4,buf,0);
	final = sc.DeSerializarTipo(*a5,buf,final);
	final = sc.DeSerializarTipo(*a6,buf,final);
	final = sc.DeSerializarTipo(*a7,buf,final);

	file2.close();

	//delete el;
	CapaFisica::Metadata* met = new CapaFisica::Metadata("Clase");
	CapaFisica::Contenedor* c = new CapaFisica::Contenedor(met);
	CapaFisica::Atributo* a = new CapaFisica::Atributo();
	a->Valor = new string("1");
	a->Tipo = 'B';
	CapaFisica::Atributo* a1 = new CapaFisica::Atributo();
	a1->Valor = new string("200.152");
	a1->Tipo = 'R';
	CapaFisica::Atributo* a2 = new CapaFisica::Atributo();
	a2->Valor = new string("abcdefghijklmnopqrstuvwxyz");
	a2->Tipo = 'S';
	CapaFisica::Atributo* a3 = new CapaFisica::Atributo();
	a3->Valor = new string("20071014");
	a3->Tipo = 'F';

	c->Atributos->insert(c->Atributos->end(),*a);
	c->Atributos->insert(c->Atributos->end(),*a1);
	c->Atributos->insert(c->Atributos->end(),*a2);
	c->Atributos->insert(c->Atributos->end(),*a3);

	CapaFisica::Serializador* ser = new CapaFisica::SerializadorContenedores(c);
	
	char* buffer = new char[512];
	int off = ser->Serializar(buffer,0);
	
	fstream file;
	file.open("datos.dat", ios::out | ios::binary);
	file.write(buffer,512);
	file.close();

	char* buffer2 = new char[512];
	fstream file2;
	file2.open("datos.dat", ios::in | ios::binary );
	file2.read(buffer2,512);
	
	CapaFisica::Atributo* a4 = new CapaFisica::Atributo();
	a4->Tipo = 'B';
	CapaFisica::Atributo* a5 = new CapaFisica::Atributo();
	a5->Tipo = 'R';
	CapaFisica::Atributo* a6 = new CapaFisica::Atributo();
	a6->Tipo = 'S';
	CapaFisica::Atributo* a7 = new CapaFisica::Atributo();
	a7->Tipo = 'F';

	CapaFisica::Contenedor* c2 = new CapaFisica::Contenedor(met);
	
	c2->Atributos->insert(c2->Atributos->end(),*a4);
	c2->Atributos->insert(c2->Atributos->end(),*a5);
	c2->Atributos->insert(c2->Atributos->end(),*a6);
	c2->Atributos->insert(c2->Atributos->end(),*a7);

	CapaFisica::Serializador* ser2 = new CapaFisica::SerializadorContenedores(c2);
	
	int off2 = ser2->Deserializar(buffer2,0);

	typedef list<CapaFisica::Atributo>::const_iterator LI;

	for (LI i = c2->Atributos->begin(); i!=c2->Atributos->end();i++){
		CapaFisica::Atributo a = *i;
		cout << *a.Valor << endl;
	}

	CapaFisica::Metadata* m = new CapaFisica::Metadata("clase");
	
	typedef list<CapaFisica::Grupo>::const_iterator LIG;
	typedef list<CapaFisica::ClaveValor>::const_iterator LICV;

	for (LIG i = m->Grupos->begin(); i!=m->Grupos->end();i++){
		CapaFisica::Grupo g = *i;
		cout << g.nombre << endl;

		for (LICV i = g.Valores->begin(); i!=g.Valores->end();i++){
			CapaFisica::ClaveValor cv = *i;
			cout << "  Clave: " << cv.Clave<< endl;
			cout << "  Valor: " << cv.Valor<< endl;
		}
	}
	
	string s;
	cin >> s;

	return 0;
}
*/
